home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / gle / util / letz / var.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-29  |  4.2 KB  |  223 lines
  1. /*---------------------------------------------------------------------------*/
  2. #include "all.h"
  3.  
  4.  
  5. #define true (!false)
  6. #define false 0
  7.  
  8. int var_local;        /* 0 = global, 1 = local */
  9. char *var_names[100];    /* Global variables */
  10. int var_type[100];
  11. int nvar;
  12. char *lvar_names[100];    /*  Local variables  */
  13. int lvar_type[100];
  14. int nlvar;
  15.  
  16. static void *dp_stack[100];
  17. static void *dp_stackstr[100];
  18. static int ndp;
  19. static double (*lvar_val)[100];
  20. static char *(*lvar_str)[100];
  21. static double var_val[100];
  22. static char *var_str[100];
  23. /*------------------------------------------------------------------*/
  24. int var_check(int *j);
  25. var_check(int *j)
  26. {
  27.     if (*j<0 || *j>400) {
  28.         gprint("Variable index is wrong %d \n",*j);
  29.         *j = 1;
  30.     }
  31.     if (lvar_val == NULL  && *j>=200) {
  32.         *j = 0;
  33.         gprint("No local variables assigned \n");
  34.     }
  35. }
  36. var_alloc_local()
  37. {
  38.     dp_stack[++ndp] = lvar_val;
  39.     dp_stackstr[ndp] = lvar_str;
  40.     lvar_val = myallocz(sizeof(*lvar_val));
  41.     lvar_str = myallocz(sizeof(*lvar_str));
  42. }
  43. var_free_local()
  44. {
  45.     if (ndp==0) {gprint("Cannot free local as none saved \n"); return;}
  46.     myfree(lvar_val);
  47.     myfree(lvar_str);
  48.     lvar_val = dp_stack[ndp];
  49.     lvar_str = dp_stackstr[ndp--];
  50. }
  51. var_set(int jj, double v)
  52. {
  53.     var_check(&jj);
  54.     if (jj<200)
  55.         var_val[jj] = v;
  56.     else
  57.         (*lvar_val)[jj-200] = v;
  58. }
  59. var_setstr(int jj, char *s)
  60. {
  61.     var_check(&jj);
  62.     if (jj<200)
  63.         mystrcpy(&var_str[jj],s);
  64.     else
  65.         mystrcpy(&(*lvar_str)[jj-200],s);
  66. }
  67. var_getstr(int jj, char *s)
  68. {
  69.     var_check(&jj);
  70.     if (jj<200) {
  71.         if (var_str[jj]!=NULL) strcpy(s,var_str[jj]);
  72.         else {
  73.             strcpy(s,"");
  74.             gprint("String Variable not defined %d \n",jj);
  75.         }
  76.     } else {
  77.         if ((*lvar_str)[jj-200]!=NULL) strcpy(s,(*lvar_str)[jj-200]);
  78.         if ((*lvar_str)[jj-200]==NULL) gprint("ERROR, variable not defined\n");
  79.     }
  80.  
  81. }
  82. var_get(int jj, double *v)
  83. {
  84.     var_check(&jj);
  85.     if (jj<200)
  86.         *v = var_val[jj];
  87.     else
  88.         *v = (*lvar_val)[jj-200];
  89. }
  90. /*------------------------------------------------------------------*/
  91. var_nlocal(int *l)
  92. {
  93.     *l = nlvar;
  94. }
  95. var_clear_global()
  96. {
  97.     nvar = 0;
  98. }
  99. var_set_local()
  100. {
  101.     var_local = true;
  102.     nlvar = 0;
  103. }
  104. var_set_global()
  105. {
  106.     var_local = false;
  107. }
  108. var_clear_local()
  109. {
  110.     nlvar = 0;
  111. }
  112. var_findadd(char *name,int *idx,int *type)    /* Add a variable to the list */
  113. {
  114.     var_find(name,idx,type);
  115.     if (*idx==-1) var_add(name,idx,type);
  116. }
  117. var_add(char *name,int *idx,int *type)    /* Add a variable to the list */
  118. {
  119. /*    if (strcmp(name,"PI")==0 &&
  120.         strcmp(name,"X")==0 &&
  121.         strcmp(name,"Y")==0)
  122.             printf("%ERROR, Illegal variable name {%s} \n",name);
  123. */
  124.     if (var_local==0) {
  125.         if (nvar>90) gprint("Too many global variables \n");
  126.         mystrcpy(&var_names[nvar],name);
  127.         *idx = nvar;
  128.         if (lastchar(name,'$')) *type=2;
  129.         else *type=1;
  130.         var_type[nvar++] = *type;
  131.     } else {
  132.         if (nlvar>90) gprint("Too many local variables \n");
  133.         mystrcpy(&lvar_names[nlvar],name);
  134.         *idx = nlvar+200;
  135.         if (lastchar(name,'$')) *type=2;
  136.         else *type=1;
  137.         lvar_type[nlvar++] = *type;
  138.     }
  139. }
  140. var_find(char *name,int *idx,int *type)    /* Find a variable in the list */
  141. {
  142.     int i;
  143. /*     if (var_local==0) { */
  144.  
  145.     for (i=0;i<nlvar;i++) {
  146.         if (strcmp(lvar_names[i],name)==0) {
  147.             *idx = i+200;
  148.             *type = lvar_type[i];
  149.             return;
  150.         }
  151.     }
  152.     for (i=0;i<nvar;i++) {
  153.         if (strcmp(var_names[i],name)==0) {
  154.             *idx = i;
  155.             *type = var_type[i];
  156.             return;
  157.         }
  158.     }
  159.     *idx = -1;
  160.  
  161.  
  162. /*     } else { */
  163. /*     } */
  164. }
  165. /*------------------------------------------------------------------*/
  166. var_find_dn(int *idx, int *var, int *nd)
  167. {
  168.     int i,d;
  169.     *nd = 0;
  170.     for (i=0;i<nlvar;i++) {
  171.         if (strncmp(lvar_names[i],"D",1)==0) {
  172.             d = atoi(lvar_names[i]+1);
  173.             if (d>0 && d<100) {
  174.                 ++*nd;
  175.                 *idx++ = i+200;
  176.                 *var++ = d;
  177.             }
  178.         }
  179.     }
  180. }
  181. var_find_rc(int *idx, int *var, int *nd, int c)
  182. {
  183.     int i,d;
  184.     *nd = 0;
  185.     for (i=0;i<nlvar;i++) {
  186.         if (*lvar_names[i]==c) {
  187.             d = atoi(lvar_names[i]+1);
  188.             if (d>0) {
  189.                 ++*nd;
  190.                 *idx++ = i+200;
  191.                 *var++ = d;
  192.             }
  193.         }
  194.     }
  195.     for (i=0;i<nvar;i++) {
  196.         if (*var_names[i]==c) {
  197.             d = atoi(var_names[i]+1);
  198.             if (d>0) {
  199.                 ++*nd;
  200.                 *idx++ = i;
  201.                 *var++ = d;
  202.             }
  203.         }
  204.     }
  205. }
  206. /*------------------------------------------------------------------*/
  207. str_var(s)
  208. char *s;
  209. {
  210.     int i;
  211.     i = strlen(s);
  212.     if (*(s+i-1)=='$') return true;
  213.       else return false;
  214. }
  215.  
  216. valid_var(s)
  217. char *s;
  218. {
  219.     return true;
  220. }
  221.  
  222. /*------------------------------------------------------------------*/
  223.